/**
 * 可继承的Service基类
 * 作为所有Service的基础类，提供通用的服务方法
 * 不继承component以避免循环依赖
 */
export abstract class BaseServiceClass {
    protected name: string;
    
    constructor() {
        this.name = this.constructor.name;
    }

    /**
     * 获取SDK实例
     * 提供便捷的SDK访问方式
     * 使用延迟导入避免循环依赖
     */
    protected get sdk() {
        // 延迟导入避免循环依赖
        return require("../core").default;
    }

    /**
     * 记录服务日志
     * @param level 日志级别
     * @param message 日志消息
     * @param data 附加数据
     */
    protected log(level: 'info' | 'warn' | 'error', message: string, data?: any) {
        const prefix = `[${this.constructor.name}]`;
        switch (level) {
            case 'info':
                console.log(prefix, message, data || '');
                break;
            case 'warn':
                console.warn(prefix, message, data || '');
                break;
            case 'error':
                console.error(prefix, message, data || '');
                break;
        }
    }

    /**
     * 统一的错误处理
     * @param error 错误对象
     * @param operation 操作名称
     * @returns 标准错误响应
     */
    protected handleError(error: any, operation: string): {
        success: false;
        message: string;
        error?: any;
    } {
        const errorMessage = `${operation}失败: ${error.message || error}`;
        this.log('error', errorMessage, error);
        
        return {
            success: false,
            message: errorMessage,
            error: process.env.NODE_ENV === 'development' ? error : undefined
        };
    }

    /**
     * 统一的成功响应
     * @param message 成功消息
     * @param data 返回数据
     */
    protected createSuccessResponse<T = any>(message: string, data?: T): {
        success: true;
        message: string;
        data?: T;
    } {
        return {
            success: true,
            message,
            data
        };
    }

    /**
     * 统一的失败响应
     * @param message 失败消息
     */
    protected createErrorResponse(message: string): {
        success: false;
        message: string;
    } {
        return {
            success: false,
            message
        };
    }

    /**
     * 验证必需参数
     * @param params 参数对象
     * @param requiredFields 必需字段列表
     * @returns 验证结果
     */
    protected validateRequiredFields(params: Record<string, any>, requiredFields: string[]): {
        valid: boolean;
        message?: string;
    } {
        for (const field of requiredFields) {
            if (params[field] === undefined || params[field] === null) {
                return {
                    valid: false,
                    message: `缺少必需参数: ${field}`
                };
            }
        }
        return { valid: true };
    }

    /**
     * 异步操作包装器，提供统一的错误处理
     * @param operation 操作函数
     * @param operationName 操作名称
     */
    protected async safeExecute<T>(
        operation: () => Promise<T>, 
        operationName: string
    ): Promise<T | { success: false; message: string; error?: any }> {
        try {
            return await operation();
        } catch (error) {
            return this.handleError(error, operationName);
        }
    }
}
